home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Utilities / Unix / cvs-960311 / info / cvs.info-5 (.txt) < prev    next >
GNU Info File  |  1996-01-24  |  43KB  |  794 lines
  1. This is Info file cvs.info, produced by Makeinfo-1.64 from the input
  2. file ./cvs.texinfo.
  3.    Copyright (C) 1992, 1993 Signum Support AB Copyright (C) 1993, 1994
  4. Free Software Foundation, Inc.
  5.    Permission is granted to make and distribute verbatim copies of this
  6. manual provided the copyright notice and this permission notice are
  7. preserved on all copies.
  8.    Permission is granted to copy and distribute modified versions of
  9. this manual under the conditions for verbatim copying, provided also
  10. that the section entitled "GNU General Public License" is included
  11. exactly as in the original, and provided that the entire resulting
  12. derived work is distributed under the terms of a permission notice
  13. identical to this one.
  14.    Permission is granted to copy and distribute translations of this
  15. manual into another language, under the above conditions for modified
  16. versions, except that the section entitled "GNU General Public License"
  17. and this permission notice may be included in translations approved by
  18. the Free Software Foundation instead of in the original English.
  19. File: cvs.info,  Node: Wrappers,  Next: commit files,  Prev: modules,  Up: Administrative files
  20. The cvswrappers file
  21. ====================
  22.    Wrappers allow you to set a hook which transforms files on their way
  23. in and out of cvs
  24.    The file `cvswrappers' defines the script that will be run on a file
  25. when its name matches a regular expresion. There are two scripts that
  26. can be run on a file or directory. One script is executed on the
  27. file/directory before being checked into the repository (this is denoted
  28. with the `-t' flag) and the other when the file is checked out of the
  29. repository (this is denoted with the `-f' flag)
  30.    The `cvswrappers' also specifies the merge methodology that should
  31. be used when the file is updated, that is should a MERGE or a straight
  32. COPY of the diferences be used when checking into the repository.
  33.    The basic format of the file `cvswrappers' is given as such:
  34.      wildcard     [option value][option value]...
  35.      
  36.      where option is one of
  37.      -f           from cvs filter         value: path tofilter
  38.      -t           to cvs filter           value: path to filter
  39.      -m           update methodology      value: MERGE or COPY
  40.      
  41.      and value is a single-quote delimited value.
  42.      *.nib    -f 'unwrap %s' -t 'wrap %s %s' -m 'COPY'
  43.      *.c      -t 'indent %s %s'
  44. The above example of a `cvswrappers' file states that all
  45. files/directories that end with a `.nib' should be filtered with the
  46. `wrap' program before checking the file into the repository. The file
  47. should be filtered though the `unwrap' program when the file is checked
  48. out of the repository. The `cvswrappers' file also states that a `COPY'
  49. methodology should be used when updating the files in the repository
  50. (that is no merging should be performed).
  51.    The last example line says that all files that end with a `*.c'
  52. should be filtered with `indent' before being checked into the
  53. repository. Unlike the previous example no filtering of the `*.c' file
  54. is done when it is checked out of the repository.
  55. The `-t' filter is called with two arguments, the first is the name of
  56. the file/directory to filter and the second is the pathname to where
  57. the resulting filtered file should be placed.
  58. The `-f' filter is called with one argument, which is the name of the
  59. file to filter from. The end result of this filter will be a file in
  60. the users directory that they can work on as they normally would.
  61. File: cvs.info,  Node: commit files,  Next: commitinfo,  Prev: Wrappers,  Up: Administrative files
  62. The commit support files
  63. ========================
  64.    The `-i' flag in the `modules' file can be used to run a certain
  65. program whenever files are committed (*note modules::.).  The files
  66. described in this section provide other, more flexible, ways to run
  67. programs whenever something is committed.
  68.    There are three kind of programs that can be run on commit.  They
  69. are specified in files in the repository, as described below.  The
  70. following table summarizes the file names and the purpose of the
  71. corresponding programs.
  72. `commitinfo'
  73.      The program is responsible for checking that the commit is
  74.      allowed.  If it exits with a non-zero exit status the commit will
  75.      be aborted.
  76. `editinfo'
  77.      The specified program is used to edit the log message, and
  78.      possibly verify that it contains all required fields.  This is
  79.      most useful in combination with the `rcsinfo' file, which can hold
  80.      a log message template (*note rcsinfo::.).
  81. `loginfo'
  82.      The specified program is called when the commit is complete.  It
  83.      receives the log message and some additional information and can
  84.      store the log message in a file, or mail it to appropriate
  85.      persons, or maybe post it to a local newsgroup, or...  Your
  86.      imagination is the limit!
  87. * Menu:
  88. * syntax::                      The common syntax
  89. File: cvs.info,  Node: syntax,  Up: commit files
  90. The common syntax
  91. -----------------
  92.    The four files `commitinfo', `loginfo', `rcsinfo' and `editinfo' all
  93. have a common format.  The purpose of the files are described later on.
  94. The common syntax is described here.
  95.    Each line contains the following:
  96.    * A regular expression
  97.    * A whitespace separator--one or more spaces and/or tabs.
  98.    * A file name or command-line template.
  99. Blank lines are ignored.  Lines that start with the character `#' are
  100. treated as comments.  Long lines unfortunately can *not* be broken in
  101. two parts in any way.
  102.    The first regular expression that matches the current directory name
  103. in the repository is used.  The rest of the line is used as a file name
  104. or command-line as appropriate.
  105. File: cvs.info,  Node: commitinfo,  Next: editinfo,  Prev: commit files,  Up: Administrative files
  106. Commitinfo
  107. ==========
  108.    The `commitinfo' file defines programs to execute whenever `cvs
  109. commit' is about to execute.  These programs are used for pre-commit
  110. checking to verify that the modified, added and removed files are really
  111. ready to be committed.  This could be used, for instance, to verify
  112. that the changed files conform to to your site's standards for coding
  113. practice.
  114.    As mentioned earlier, each line in the `commitinfo' file consists of
  115. a regular expression and a command-line template.  The template can
  116. include a program name and any number of arguments you wish to supply
  117. to it.  The full path to the current source repository is appended to
  118. the template, followed by the file names of any files involved in the
  119. commit (added, removed, and modified files).
  120.    The first line with a regular expression matching the relative path
  121. to the module will be used.  If the command returns a non-zero exit
  122. status the commit will be aborted.
  123.    If the repository name does not match any of the regular expressions
  124. in this file, the `DEFAULT' line is used, if it is specified.
  125.    All occurances of the name `ALL' appearing as a regular expression
  126. are used in addition to the first matching regular expression or the
  127. name `DEFAULT'.
  128.    Note: when CVS is accessing a remote repository, `commitinfo' will
  129. be run on the *remote* (i.e., server) side, not the client side (*note
  130. Remote repositories::.).
  131. File: cvs.info,  Node: editinfo,  Next: loginfo,  Prev: commitinfo,  Up: Administrative files
  132. Editinfo
  133. ========
  134.    If you want to make sure that all log messages look the same way,
  135. you can use the `editinfo' file to specify a program that is used to
  136. edit the log message.  This program could be a custom-made editor that
  137. always enforces a certain style of the log message, or maybe a simple
  138. shell script that calls an editor, and checks that the entered message
  139. contains the required fields.
  140.    If no matching line is found in the `editinfo' file, the editor
  141. specified in the environment variable `$CVSEDITOR' is used instead.  If
  142. that variable is not set, then the environment variable `$EDITOR' is
  143. used instead.  If that variable is not set a precompiled default,
  144. normally `vi', will be used.
  145.    The `editinfo' file is often most useful together with the `rcsinfo'
  146. file, which can be used to specify a log message template.
  147.    Each line in the `editinfo' file consists of a regular expression
  148. and a command-line template.  The template must include a program name,
  149. and can include any number of arguments.  The full path to the current
  150. log message template file is appended to the template.
  151.    One thing that should be noted is that the `ALL' keyword is not
  152. supported.  If more than one matching line is found, the first one is
  153. used.  This can be useful for specifying a default edit script in a
  154. module, and then overriding it in a subdirectory.
  155.    If the repository name does not match any of the regular expressions
  156. in this file, the `DEFAULT' line is used, if it is specified.
  157.    If the edit script exits with a non-zero exit status, the commit is
  158. aborted.
  159.    Note: when CVS is accessing a remote repository, `editinfo' will be
  160. run on the *remote* (i.e., server) side, not the client side (*note
  161. Remote repositories::.).
  162. * Menu:
  163. * editinfo example::            Editinfo example
  164. File: cvs.info,  Node: editinfo example,  Up: editinfo
  165. Editinfo example
  166. ----------------
  167.    The following is a little silly example of a `editinfo' file,
  168. together with the corresponding `rcsinfo' file, the log message
  169. template and an editor script.  We begin with the log message template.
  170. We want to always record a bug-id number on the first line of the log
  171. message.  The rest of log message is free text.  The following template
  172. is found in the file `/usr/cvssupport/tc.template'.
  173.      BugId:
  174.    The script `/usr/cvssupport/bugid.edit' is used to edit the log
  175. message.
  176.      #!/bin/sh
  177.      #
  178.      #       bugid.edit filename
  179.      #
  180.      #  Call $EDITOR on FILENAME, and verify that the
  181.      #  resulting file contains a valid bugid on the first
  182.      #  line.
  183.      if [ "x$EDITOR" = "x" ]; then EDITOR=vi; fi
  184.      if [ "x$CVSEDITOR" = "x" ]; then CVSEDITOR=$EDITOR; fi
  185.      $CVSEDITOR $1
  186.      until head -1|grep '^BugId:[ ]*[0-9][0-9]*$' < $1
  187.      do  echo -n  "No BugId found.  Edit again? ([y]/n)"
  188.          read ans
  189.          case ${ans} in
  190.              n*) exit 1;;
  191.          esac
  192.          $CVSEDITOR $1
  193.      done
  194.    The `editinfo' file contains this line:
  195.      ^tc     /usr/cvssupport/bugid.edit
  196.    The `rcsinfo' file contains this line:
  197.      ^tc     /usr/cvssupport/tc.template
  198. File: cvs.info,  Node: loginfo,  Next: rcsinfo,  Prev: editinfo,  Up: Administrative files
  199. Loginfo
  200. =======
  201.    The `loginfo' file is used to control where `cvs commit' log
  202. information is sent.  The first entry on a line is a regular expression
  203. which is tested against the directory that the change is being made to,
  204. relative to the `$CVSROOT'.  If a match is found, then the remainder of
  205. the line is a filter program that should expect log information on its
  206. standard input.
  207.    The filter program may use one and only one % modifier (a la
  208. printf).  If `%s' is specified in the filter program, a brief title is
  209. included (enclosed in single quotes) showing the modified file names.
  210.    If the repository name does not match any of the regular expressions
  211. in this file, the `DEFAULT' line is used, if it is specified.
  212.    All occurances of the name `ALL' appearing as a regular expression
  213. are used in addition to the first matching regular expression or
  214. `DEFAULT'.
  215.    The first matching regular expression is used.
  216.    *Note commit files::, for a description of the syntax of the
  217. `loginfo' file.
  218.    Note: when CVS is accessing a remote repository, `loginfo' will be
  219. run on the *remote* (i.e., server) side, not the client side (*note
  220. Remote repositories::.).
  221. * Menu:
  222. * loginfo example::             Loginfo example
  223. File: cvs.info,  Node: loginfo example,  Up: loginfo
  224. Loginfo example
  225. ---------------
  226.    The following `loginfo' file, together with the tiny shell-script
  227. below, appends all log messages to the file
  228. `$CVSROOT/CVSROOT/commitlog', and any commits to the administrative
  229. files (inside the `CVSROOT' directory) are also logged in
  230. `/usr/adm/cvsroot-log' and mailed to ceder.
  231.      ALL             /usr/local/bin/cvs-log $CVSROOT/CVSROOT/commitlog
  232.      ^CVSROOT        Mail -s %s ceder
  233.      ^CVSROOT        /usr/local/bin/cvs-log /usr/adm/cvsroot-log
  234.    The shell-script `/usr/local/bin/cvs-log' looks like this:
  235.      #!/bin/sh
  236.      (echo "-----------------------------------------------------------------";
  237.       echo -n $USER"  ";
  238.       date;
  239.       echo;
  240.       sed '1s+'${CVSROOT}'++') >> $1
  241. File: cvs.info,  Node: rcsinfo,  Next: cvsignore,  Prev: loginfo,  Up: Administrative files
  242. Rcsinfo
  243. =======
  244.    The `rcsinfo' file can be used to specify a form to edit when
  245. filling out the commit log.  The `rcsinfo' file has a syntax similar to
  246. the `editinfo', `commitinfo' and `loginfo' files.  *Note syntax::.
  247. Unlike the other files the second part is *not* a command-line
  248. template.  Instead, the part after the regular expression should be a
  249. full pathname to a file containing the log message template.
  250.    If the repository name does not match any of the regular expressions
  251. in this file, the `DEFAULT' line is used, if it is specified.
  252.    All occurances of the name `ALL' appearing as a regular expression
  253. are used in addition to the first matching regular expression or
  254. `DEFAULT'.
  255.    The log message template will be used as a default log message.  If
  256. you specify a log message with `cvs commit -m MESSAGE' or `cvs commit -f
  257. FILE' that log message will override the template.
  258.    *Note editinfo example::, for an example `rcsinfo' file.
  259.    Note: when CVS is accessing a remote repository, `rcsinfo' will be
  260. run on the *remote* (i.e., server) side, not the client side (*note
  261. Remote repositories::.).
  262. File: cvs.info,  Node: cvsignore,  Next: history file,  Prev: rcsinfo,  Up: Administrative files
  263. Ignoring files via cvsignore
  264. ============================
  265.    There are certain file names that frequently occur inside your
  266. working copy, but that you don't want to put under CVS control.
  267. Examples are all the object files that you get while you compile your
  268. sources.  Normally, when you run `cvs update', it prints a line for
  269. each file it encounters that it doesn't know about (*note update
  270. output::.).
  271.    CVS has a list of files (or sh(1) file name patterns) that it should
  272. ignore while running `update', `import' and `release'.  This list is
  273. constructed in the following way.
  274.    * The list is initialized to include certain file name patterns:
  275.      names associated with CVS administration, or with other common
  276.      source control systems; common names for patch files, object files,
  277.      archive files, and editor backup files; and other names that are
  278.      usually artifacts of assorted utilities.  Currently, the default
  279.      list of ignored file name patterns is:
  280.               RCS     SCCS    CVS     CVS.adm
  281.               RCSLOG  cvslog.*
  282.               tags    TAGS
  283.               .make.state     .nse_depinfo
  284.               *~      #*      .#*     ,*
  285.               *.old   *.bak   *.BAK   *.orig  *.rej   .del-*
  286.               *.a     *.o     *.obj   *.so    *.Z     *.elc   *.ln
  287.               core
  288.    * The per-repository list in `$CVSROOT/CVSROOT/cvsignore' is
  289.      appended to the list, if that file exists.
  290.    * The per-user list in `.cvsignore' in your home directory is
  291.      appended to the list, if it exists.
  292.    * Any entries in the environment variable `$CVSIGNORE' is appended
  293.      to the list.
  294.    * Any `-I' options given to CVS is appended.
  295.    * As CVS traverses through your directories, the contents of any
  296.      `.cvsignore' will be appended to the list.  The patterns found in
  297.      `.cvsignore' are only valid for the directory that contains them,
  298.      not for any sub-directories.
  299.    In any of the 5 places listed above, a single exclamation mark (`!')
  300. clears the ignore list.  This can be used if you want to store any file
  301. which normally is ignored by CVS.
  302. File: cvs.info,  Node: history file,  Next: Setting up,  Prev: cvsignore,  Up: Administrative files
  303. The history file
  304. ================
  305.    The file `$CVSROOT/CVSROOT/history' is used to log information for
  306. the `history' command (*note history::.).  This file must be created to
  307. turn on logging.  This is done automatically if the `cvsinit' script is
  308. used to set up the repository.
  309.    The file format of the `history' file is unfortunately not yet
  310. documented anywhere, but it is fairly easy to understand most of it.
  311. File: cvs.info,  Node: Setting up,  Prev: history file,  Up: Administrative files
  312. Setting up the repository
  313. =========================
  314.    When you install CVS for the first time, you should follow the
  315. instructions in the `INSTALL' file to set up the repository.
  316.    If you want to set up another repository, the easiest way to get a
  317. reasonable set of working administrative files is to run the `cvsinit'
  318. shell script.  It will set up an empty repository in the directory
  319. defined by the environment variable `$CVSROOT'.  (`cvsinit' is careful
  320. to never overwrite any existing files in the repository, so no harm is
  321. done if you run `cvsinit' on an already set-up repository.  In fact,
  322. running it on an already set-up repository is the best way to update
  323. the various scripts from the `contrib' directory.)
  324. File: cvs.info,  Node: Environment variables,  Next: Troubleshooting,  Prev: Administrative files,  Up: Top
  325. All environment variables which affect CVS
  326. ******************************************
  327.    This is a complete list of all environment variables that affect CVS.
  328. `$CVSIGNORE'
  329.      A whitespace-separated list of file name patterns that CVS should
  330.      ignore. *Note cvsignore::.
  331. `$CVSWRAPPERS'
  332.      A whitespace-separated list of file name patterns that CVS should
  333.      treat as wrappers. *Note Wrappers::.
  334. `$CVSREAD'
  335.      If this is set, `checkout' and `update' will try hard to make the
  336.      files in your working directory read-only.  When this is not set,
  337.      the default behavior is to permit modification of your working
  338.      files.
  339. `$CVSROOT'
  340.      Should contain the full pathname to the root of the CVS source
  341.      repository (where the RCS history files are kept).  This
  342.      information must be available to CVS for most commands to execute;
  343.      if `$CVSROOT' is not set, or if you wish to override it for one
  344.      invocation, you can supply it on the command line: `cvs -d cvsroot
  345.      cvs_command...' Once you have checked out a working directory, CVS
  346.      stores the appropriate root (in the file `CVS/Root'), so normally
  347.      you only need to worry about this when initially checking out a
  348.      working directory.
  349. `$EDITOR'
  350. `$CVSEDITOR'
  351.      Specifies the program to use for recording log messages during
  352.      commit.  If not set, the default is `/usr/ucb/vi'.  `$CVSEDITOR'
  353.      overrides `$EDITOR'.  `$CVSEDITOR' does not exist in CVS 1.3, but
  354.      the next release will probably include it.
  355. `$PATH'
  356.      If `$RCSBIN' is not set, and no path is compiled into CVS, it will
  357.      use `$PATH' to try to find all programs it uses.
  358. `$RCSBIN'
  359.      Specifies the full pathname of the location of RCS programs, such
  360.      as co(1) and ci(1).  If not set, a compiled-in value is used, or
  361.      your `$PATH' is searched.
  362.    CVS is a front-end to RCS.  The following environment variables
  363. affect RCS:
  364. `$LOGNAME'
  365. `$USER'
  366.      If set, they affect who RCS thinks you are.  If you have trouble
  367.      checking in files it might be because your login name differs from
  368.      the setting of e.g.  `$LOGNAME'.
  369. `$RCSINIT'
  370.      Options prepended to the argument list, separated by spaces.  A
  371.      backslash escapes spaces within an option.  The `$RCSINIT' options
  372.      are prepended to the argument lists of most RCS commands.
  373. `$TMPDIR'
  374. `$TMP'
  375. `$TEMP'
  376.      Name of the temporary directory.  The environment variables are
  377.      inspected in the order they appear above and the first value found
  378.      is taken; if none of them are set, a host-dependent default is
  379.      used, typically `/tmp'.
  380. File: cvs.info,  Node: Troubleshooting,  Next: Copying,  Prev: Environment variables,  Up: Top
  381. Troubleshooting
  382. ***************
  383. * Menu:
  384. * Magic branch numbers::        Magic branch numbers
  385. File: cvs.info,  Node: Magic branch numbers,  Up: Troubleshooting
  386. Magic branch numbers
  387. ====================
  388.    Externally, branch numbers consist of an odd number of dot-separated
  389. decimal integers.  *Note Revision numbers::.  That is not the whole
  390. truth, however.  For efficiency reasons CVS sometimes inserts an extra 0
  391. in the second rightmost position (1.2.3 becomes 1.2.0.3, 8.9.10.11.12
  392. becomes 8.9.10.11.0.12 and so on).
  393.    CVS does a pretty good job at hiding these so called magic branches,
  394. but in at least four places the hiding is incomplete.
  395.    * The magic branch can appear in the output from `cvs status' in
  396.      vanilla CVS 1.3.  This is fixed in CVS 1.3-s2.
  397.    * The magic branch number appears in the output from `cvs log'.
  398.      This is much harder to fix, since `cvs log' runs `rlog' (which is
  399.      part of the RCS distribution), and modifying `rlog' to know about
  400.      magic branches would probably break someone's habits (if they use
  401.      branch 0 for their own purposes).
  402.    * You cannot specify a symbolic branch name to `cvs log'.
  403.    * You cannot specify a symbolic branch name to `cvs admin'.
  404.    You can use the `admin' command to reassign a symbolic name to a
  405. branch the way RCS expects it to be.  If `R4patches' is assigned to the
  406. branch 1.4.2 (magic branch number 1.4.0.2) in file `numbers.c' you can
  407. do this:
  408.      $ cvs admin -NR4patches:1.4.2 numbers.c
  409.    It only works if at least one revision is already committed on the
  410. branch.  Be very careful so that you do not assign the tag to the wrong
  411. number.  (There is no way to see how the tag was assigned yesterday).
  412. File: cvs.info,  Node: Copying,  Next: Index,  Prev: Troubleshooting,  Up: Top
  413. GNU GENERAL PUBLIC LICENSE
  414. **************************
  415. File: cvs.info,  Node: Index,  Prev: Copying,  Up: Top
  416. Index
  417. *****
  418. * Menu:
  419. * -j (merging branches):                Merging a branch.
  420. * -k (RCS kflags):                      Substitution modes.
  421. * .bashrc:                              Repository.
  422. * .cshrc:                               Repository.
  423. * .cvsrc file:                          ~/.cvsrc.
  424. * .profile:                             Repository.
  425. * .tcshrc:                              Repository.
  426. * /usr/local/cvsroot:                   Repository.
  427. * <<<<<<<:                              Conflicts example.
  428. * =======:                              Conflicts example.
  429. * >>>>>>>:                              Conflicts example.
  430. * A sample session:                     A sample session.
  431. * About this manual:                    Preface.
  432. * Add (subcommand):                     add.
  433. * Add options:                          add options.
  434. * Adding a tag:                         Tags.
  435. * Adding files:                         Adding files.
  436. * Admin (subcommand):                   admin.
  437. * Administrative files (intro):         Intro administrative files.
  438. * Administrative files (reference):     Administrative files.
  439. * Administrative files, editing them:   Intro administrative files.
  440. * ALL in commitinfo:                    commitinfo.
  441. * Atomic transactions, lack of:         Concurrency.
  442. * authenticated client, using:          Password authentication client.
  443. * authenticating server, setting up:    Password authentication server.
  444. * Author keyword:                       Keyword list.
  445. * Automatically ignored files:          cvsignore.
  446. * Avoiding editor invocation:           Common options.
  447. * Binary files:                         Binary files.
  448. * Branch merge example:                 Merging a branch.
  449. * Branch number:                        Revision numbers.
  450. * Branch numbers:                       Creating a branch.
  451. * Branch, creating a:                   Creating a branch.
  452. * Branch, vendor-:                      Tracking sources.
  453. * Branches:                             Branches.
  454. * Branches motivation:                  Branches motivation.
  455. * Branches, copying changes between:    Merging.
  456. * Branches, sticky:                     Sticky tags.
  457. * Bringing a file up to date:           Updating a file.
  458. * Bugs, known in this manual:           BUGS.
  459. * Bugs, reporting (manual):             BUGS.
  460. * Changes, copying between branches:    Merging.
  461. * Changing a log message:               admin options.
  462. * Checkin program:                      modules.
  463. * Checking commits:                     commitinfo.
  464. * Checking out source:                  Getting the source.
  465. * Checkout (subcommand):                checkout.
  466. * Checkout program:                     modules.
  467. * Checkout, example:                    Getting the source.
  468. * Cleaning up:                          Cleaning up.
  469. * Client/Server Operation:              Remote repositories.
  470. * Co (subcommand):                      checkout.
  471. * Command reference:                    Invoking CVS.
  472. * Command structure:                    Structure.
  473. * Comment leader:                       admin examples.
  474. * Commit (subcommand):                  commit.
  475. * Commit files:                         commit files.
  476. * Commit, when to:                      When to commit.
  477. * Commitinfo:                           commitinfo.
  478. * Committing changes:                   Committing your changes.
  479. * Common options:                       Common options.
  480. * Common syntax of info files:          syntax.
  481. * Conflict markers:                     Conflicts example.
  482. * Conflict resolution:                  Conflicts example.
  483. * Conflicts (merge example):            Conflicts example.
  484. * Contributors (CVS program):           What is CVS?.
  485. * Contributors (manual):                Credits.
  486. * Copying changes:                      Merging.
  487. * Correcting a log message:             admin options.
  488. * Creating a branch:                    Creating a branch.
  489. * Creating a project:                   Starting a new project.
  490. * Creating a repository:                Setting up.
  491. * Credits (CVS program):                What is CVS?.
  492. * Credits (manual):                     Credits.
  493. * CVS 1.6, and watches:                 Watches Compatibility.
  494. * CVS command structure:                Structure.
  495. * CVS FAQ:                              What is CVS?.
  496. * CVS FTP site:                         What is CVS?.
  497. * CVS passwd file:                      Password authentication server.
  498. * CVS, history of:                      What is CVS?.
  499. * CVS, introduction to:                 What is CVS?.
  500. * CVS_CLIENT_PORT:                      Kerberos authenticated.
  501. * CVS_PASSFILE, environment variable:   Password authentication client.
  502. * CVS_PASSWORD, environment variable:   Password authentication client.
  503. * CVS_SERVER:                           Connecting via rsh.
  504. * CVSEDITOR:                            Environment variables.
  505. * CVSEDITOR, environment variable:      Committing your changes.
  506. * CVSIGNORE:                            Environment variables.
  507. * Cvsignore, global:                    cvsignore.
  508. * CVSREAD:                              Environment variables.
  509. * CVSREAD, overriding:                  Global options.
  510. * CVSROOT:                              Environment variables.
  511. * cvsroot:                              Repository.
  512. * CVSROOT (file):                       Administrative files.
  513. * CVSROOT, environment variable:        Repository.
  514. * CVSROOT, module name:                 Intro administrative files.
  515. * CVSROOT, multiple repositories:       Multiple repositories.
  516. * CVSROOT, overriding:                  Global options.
  517. * cvswrappers (admin file):             Wrappers.
  518. * CVSWRAPPERS, environment variable:    Wrappers.
  519. * Date keyword:                         Keyword list.
  520. * Dates:                                Common options.
  521. * Decimal revision number:              Revision numbers.
  522. * DEFAULT in commitinfo:                commitinfo.
  523. * DEFAULT in editinfo:                  editinfo.
  524. * Defining a module:                    Defining the module.
  525. * Defining modules (intro):             Intro administrative files.
  526. * Defining modules (reference manual):  modules.
  527. * Deleting files:                       Removing files.
  528. * Deleting revisions:                   admin options.
  529. * Deleting sticky tags:                 Sticky tags.
  530. * Descending directories:               Recursive behavior.
  531. * Diff:                                 Viewing differences.
  532. * Diff (subcommand):                    diff.
  533. * Differences, merging:                 Merging two revisions.
  534. * Directories, moving:                  Moving directories.
  535. * Directory, descending:                Recursive behavior.
  536. * Disjoint repositories:                Multiple repositories.
  537. * Distributing log messages:            loginfo.
  538. * driver.c (merge example):             Conflicts example.
  539. * edit (subcommand):                    Editing files.
  540. * Editinfo:                             editinfo.
  541. * Editing administrative files:         Intro administrative files.
  542. * Editing the modules file:             Defining the module.
  543. * EDITOR:                               Environment variables.
  544. * Editor, avoiding invocation of:       Common options.
  545. * EDITOR, environment variable:         Committing your changes.
  546. * EDITOR, overriding:                   Global options.
  547. * Editor, specifying per module:        editinfo.
  548. * editors (subcommand):                 Watch information.
  549. * emerge:                               Conflicts example.
  550. * Environment variables:                Environment variables.
  551. * Errors, reporting (manual):           BUGS.
  552. * Example of a work-session:            A sample session.
  553. * Example of merge:                     Conflicts example.
  554. * Example, branch merge:                Merging a branch.
  555. * Export (subcommand):                  export.
  556. * Export program:                       modules.
  557. * FAQ:                                  What is CVS?.
  558. * Fetching source:                      Getting the source.
  559. * File locking:                         Multiple developers.
  560. * File permissions:                     File permissions.
  561. * File status:                          File status.
  562. * Files, moving:                        Moving files.
  563. * Files, reference manual:              Administrative files.
  564. * Fixes to CVS:                         What is CVS?.
  565. * Fixing a log message:                 admin options.
  566. * Forcing a tag match:                  Common options.
  567. * Form for log message:                 rcsinfo.
  568. * Format of CVS commands:               Structure.
  569. * Four states of a file:                File status.
  570. * FTP site:                             What is CVS?.
  571. * Getting started:                      A sample session.
  572. * Getting the source:                   Getting the source.
  573. * Global cvsignore:                     cvsignore.
  574. * Global options:                       Global options.
  575. * Group:                                File permissions.
  576. * Header keyword:                       Keyword list.
  577. * History (subcommand):                 history.
  578. * History file:                         history file.
  579. * History files:                        User modules.
  580. * History of CVS:                       What is CVS?.
  581. * Id keyword:                           Keyword list.
  582. * Ident (shell command):                Using keywords.
  583. * Identifying files:                    Keyword substitution.
  584. * Ignored files:                        cvsignore.
  585. * Ignoring files:                       cvsignore.
  586. * Import (subcommand):                  import.
  587. * Importing files:                      From files.
  588. * Importing modules:                    First import.
  589. * Index:                                Index.
  590. * Info files (syntax):                  syntax.
  591. * Informing others:                     Informing others.
  592. * Introduction to CVS:                  What is CVS?.
  593. * Invoking CVS:                         Invoking CVS.
  594. * Join:                                 Merging a branch.
  595. * kerberos:                             Kerberos authenticated.
  596. * Keyword expansion:                    Keyword substitution.
  597. * Keyword substitution:                 Keyword substitution.
  598. * Kflag:                                Substitution modes.
  599. * kinit:                                Kerberos authenticated.
  600. * Known bugs in this manual:            BUGS.
  601. * Layout of repository:                 Repository.
  602. * Left-hand options:                    Global options.
  603. * Linear development:                   Revision numbers.
  604. * List, mailing list:                   What is CVS?.
  605. * Locally modified:                     File status.
  606. * Locker keyword:                       Keyword list.
  607. * Locking files:                        Multiple developers.
  608. * locks, cvs:                           Concurrency.
  609. * Log (subcommand):                     log.
  610. * Log information, saving:              history file.
  611. * Log keyword:                          Keyword list.
  612. * Log keyword, selecting comment leader: admin examples.
  613. * Log message entry:                    Committing your changes.
  614. * Log message template:                 rcsinfo.
  615. * Log message, correcting:              admin options.
  616. * Log messages:                         loginfo.
  617. * Log messages, editing:                editinfo.
  618. * Login (subcommand):                   Password authentication client.
  619. * Loginfo:                              loginfo.
  620. * LOGNAME:                              Environment variables.
  621. * Mail, automatic mail on commit:       Informing others.
  622. * Mailing list:                         What is CVS?.
  623. * Mailing log messages:                 loginfo.
  624. * Main trunk (intro):                   Revision numbers.
  625. * Main trunk and branches:              Branches.
  626. * Many repositories:                    Multiple repositories.
  627. * Markers, conflict:                    Conflicts example.
  628. * Merge, an example:                    Conflicts example.
  629. * Merge, branch example:                Merging a branch.
  630. * Merging:                              Merging.
  631. * Merging a branch:                     Merging a branch.
  632. * Merging a file:                       Updating a file.
  633. * Merging two revisions:                Merging two revisions.
  634. * mkmodules:                            Intro administrative files.
  635. * Modifications, copying between branches: Merging.
  636. * Module status:                        modules.
  637. * Module, defining:                     Defining the module.
  638. * Modules (admin file):                 modules.
  639. * Modules (intro):                      Basic concepts.
  640. * Modules file:                         Intro administrative files.
  641. * Modules file, changing:               Defining the module.
  642. * Motivation for branches:              Branches motivation.
  643. * Moving directories:                   Moving directories.
  644. * Moving files:                         Moving files.
  645. * Multiple developers:                  Multiple developers.
  646. * Multiple repositories:                Multiple repositories.
  647. * Name, symbolic (tag):                 Tags.
  648. * Needing merge:                        File status.
  649. * Needing update:                       File status.
  650. * Nroff (selecting comment leader):     admin examples.
  651. * Number, branch:                       Revision numbers.
  652. * Number, revision-:                    Revision numbers.
  653. * option defaults:                      ~/.cvsrc.
  654. * Options, global:                      Global options.
  655. * Outdating revisions:                  admin options.
  656. * Overlap:                              Updating a file.
  657. * Overriding CVSREAD:                   Global options.
  658. * Overriding CVSROOT:                   Global options.
  659. * Overriding EDITOR:                    Global options.
  660. * Overriding RCSBIN:                    Global options.
  661. * Parallel repositories:                Multiple repositories.
  662. * passwd file:                          Password authentication server.
  663. * password client, using:               Password authentication client.
  664. * password server, setting up:          Password authentication server.
  665. * Patches to CVS:                       What is CVS?.
  666. * PATH:                                 Environment variables.
  667. * Per-module editor:                    editinfo.
  668. * Policy:                               When to commit.
  669. * Precommit checking:                   commitinfo.
  670. * Preface:                              Preface.
  671. * Pserver (subcommand):                 Password authentication server.
  672. * RCS history files:                    User modules.
  673. * RCS keywords:                         Keyword list.
  674. * RCS revision numbers:                 Tags.
  675. * RCS, CVS uses RCS:                    User modules.
  676. * RCSBIN:                               Environment variables.
  677. * RCSBIN, overriding:                   Global options.
  678. * RCSfile keyword:                      Keyword list.
  679. * Rcsinfo:                              rcsinfo.
  680. * RCSINIT:                              Environment variables.
  681. * Rdiff (subcommand):                   rdiff.
  682. * Read-only files:                      Global options.
  683. * Read-only mode:                       Global options.
  684. * Recursive (directory descending):     Recursive behavior.
  685. * Reference manual (files):             Administrative files.
  686. * Reference manual for variables:       Environment variables.
  687. * Reference, commands:                  Invoking CVS.
  688. * Release (subcommand):                 release.
  689. * Releases, revisions and versions:     Versions revisions releases.
  690. * Releasing your working copy:          Cleaning up.
  691. * Remote repositories:                  Remote repositories.
  692. * Remove (subcommand):                  remove.
  693. * Removing a change:                    Merging two revisions.
  694. * Removing files:                       Removing files.
  695. * Removing your working copy:           Cleaning up.
  696. * Renaming directories:                 Moving directories.
  697. * Renaming files:                       Moving files.
  698. * Replacing a log message:              admin options.
  699. * Reporting bugs (manual):              BUGS.
  700. * Repositories, multiple:               Multiple repositories.
  701. * Repositories, remote:                 Remote repositories.
  702. * Repository (intro):                   Basic concepts.
  703. * Repository, example:                  Repository.
  704. * Repository, setting up:               Setting up.
  705. * Repository, user parts:               User modules.
  706. * Resetting sticky tags:                Sticky tags.
  707. * Resolving a conflict:                 Conflicts example.
  708. * Retrieving an old revision using tags: Tags.
  709. * Revision keyword:                     Keyword list.
  710. * Revision management:                  Revision management.
  711. * Revision numbers:                     Revision numbers.
  712. * Revision tree:                        Revision numbers.
  713. * Revision tree, making branches:       Branches.
  714. * Revisions, merging differences between: Merging two revisions.
  715. * Revisions, versions and releases:     Versions revisions releases.
  716. * Right-hand options:                   Common options.
  717. * rsh:                                  Connecting via rsh.
  718. * Rtag (subcommand):                    rtag.
  719. * rtag, creating a branch using:        Creating a branch.
  720. * Saving space:                         admin options.
  721. * Security:                             File permissions.
  722. * setgid:                               File permissions.
  723. * Setting up a repository:              Setting up.
  724. * setuid:                               File permissions.
  725. * Signum Support:                       Preface.
  726. * Source keyword:                       Keyword list.
  727. * Source, getting CVS source:           What is CVS?.
  728. * Source, getting from CVS:             Getting the source.
  729. * Specifying dates:                     Common options.
  730. * Spreading information:                Informing others.
  731. * Starting a project with CVS:          Starting a new project.
  732. * State keyword:                        Keyword list.
  733. * Status (subcommand):                  status.
  734. * Status of a file:                     File status.
  735. * Status of a module:                   modules.
  736. * Sticky tags:                          Sticky tags.
  737. * Sticky tags, resetting:               Sticky tags.
  738. * Storing log messages:                 loginfo.
  739. * Structure:                            Structure.
  740. * Subdirectories:                       Recursive behavior.
  741. * Support, getting CVS support:         Preface.
  742. * Symbolic name (tag):                  Tags.
  743. * Syntax of info files:                 syntax.
  744. * Tag (subcommand):                     tag.
  745. * Tag program:                          modules.
  746. * tag, command, introduction:           Tags.
  747. * tag, example:                         Tags.
  748. * Tag, retrieving old revisions:        Tags.
  749. * Tag, symbolic name:                   Tags.
  750. * Tags:                                 Tags.
  751. * Tags, sticky:                         Sticky tags.
  752. * tc, Trivial Compiler (example):       A sample session.
  753. * Team of developers:                   Multiple developers.
  754. * TEMP:                                 Environment variables.
  755. * Template for log message:             rcsinfo.
  756. * Third-party sources:                  Tracking sources.
  757. * Time:                                 Common options.
  758. * TMP:                                  Environment variables.
  759. * TMPDIR:                               Environment variables.
  760. * Trace:                                Global options.
  761. * Tracking sources:                     Tracking sources.
  762. * Transactions, atomic, lack of:        Concurrency.
  763. * Trivial Compiler (example):           A sample session.
  764. * Typical repository:                   Repository.
  765. * Undoing a change:                     Merging two revisions.
  766. * unedit (subcommand):                  Editing files.
  767. * Up-to-date:                           File status.
  768. * Update (subcommand):                  update.
  769. * Update program:                       modules.
  770. * update, introduction:                 Updating a file.
  771. * Updating a file:                      Updating a file.
  772. * USER:                                 Environment variables.
  773. * User modules:                         User modules.
  774. * users (admin file):                   Getting Notified.
  775. * Vendor:                               Tracking sources.
  776. * Vendor branch:                        Tracking sources.
  777. * Versions, revisions and releases:     Versions revisions releases.
  778. * Viewing differences:                  Viewing differences.
  779. * watch add (subcommand):               Getting Notified.
  780. * watch off (subcommand):               Setting a watch.
  781. * watch on (subcommand):                Setting a watch.
  782. * watch remove (subcommand):            Getting Notified.
  783. * watchers (subcommand):                Watch information.
  784. * Watches:                              Watches.
  785. * Wdiff (import example):               First import.
  786. * What (shell command):                 Using keywords.
  787. * What branches are good for:           Branches motivation.
  788. * What is CVS?:                         What is CVS?.
  789. * When to commit:                       When to commit.
  790. * Work-session, example of:             A sample session.
  791. * Working copy:                         Multiple developers.
  792. * Working copy, removing:               Cleaning up.
  793. * Wrappers:                             Wrappers.
  794.